精通 AsyncIO：面向全球开发者的 Python 协程调试与错误处理策略

            import asyncio

async def fetch_data(url):
    print(f"Fetching data from {url}...")
    await asyncio.sleep(1) # Simulate network delay
    if "error" in url:
        raise ValueError(f"Failed to fetch from {url}")
    return f"Data from {url}"

async def process_urls(urls):
    tasks = []
    for url in urls:
        tasks.append(asyncio.create_task(fetch_data(url)))

    results = []
    for task in asyncio.as_completed(tasks):
        try:
            result = await task
            results.append(result)
            print(f"Successfully processed: {result}")
        except ValueError as e:
            print(f"Error processing URL: {e}")
        except Exception as e:
            print(f"An unexpected error occurred: {e}")
        finally:
            # Code here runs whether an exception occurred or not
            print("Finished processing one task.")
    return results

async def main():
    urls = [
        "http://example.com/data1",
        "http://example.com/error_source",
        "http://example.com/data2"
    ]
    await process_urls(urls)

if __name__ == "__main__":
    asyncio.run(main())

            

              
                Copy
              
            
          

            import asyncio

async def cancellable_task():
    try:
        for i in range(5):
            print(f"Task step {i}")
            await asyncio.sleep(1)
        print("Task completed normally.")
    except asyncio.CancelledError:
        print("Task was cancelled! Performing cleanup...")
        # Simulate cleanup operations
        await asyncio.sleep(0.5)
        print("Cleanup finished.")
        raise # Re-raise CancelledError if required by convention
    finally:
        print("This finally block always runs.")

async def main():
    task = asyncio.create_task(cancellable_task())
    await asyncio.sleep(2.5) # Let the task run for a bit
    print("Cancelling the task...")
    task.cancel()
    try:
        await task # Wait for the task to acknowledge cancellation
    except asyncio.CancelledError:
        print("Main caught CancelledError after task cancellation.")

if __name__ == "__main__":
    asyncio.run(main())

            

              
                Copy
              
            
          

            import asyncio

async def successful_operation(delay):
    await asyncio.sleep(delay)
    return f"Success after {delay}s"

async def failing_operation(delay):
    await asyncio.sleep(delay)
    raise RuntimeError(f"Failed after {delay}s")

async def main():
    results = await asyncio.gather(
        successful_operation(1),
        failing_operation(0.5),
        successful_operation(1.5),
        return_exceptions=True
    )

    print("Results from gather:")
    for i, result in enumerate(results):
        if isinstance(result, Exception):
            print(f"Task {i}: Failed with exception: {result}")
        else:
            print(f"Task {i}: Succeeded with result: {result}")

if __name__ == "__main__":
    asyncio.run(main())

            

              
                Copy
              
            
          

            import asyncio

class AsyncResource:
    def __init__(self, name):
        self.name = name
        self.acquired = False

    async def __aenter__(self):
        print(f"Acquiring resource: {self.name}")
        await asyncio.sleep(0.2) # Simulate acquisition time
        self.acquired = True
        return self

    async def __aexit__(self, exc_type, exc_val, exc_tb):
        print(f"Releasing resource: {self.name}")
        await asyncio.sleep(0.2) # Simulate release time
        self.acquired = False
        if exc_type:
            print(f"An exception occurred within the context: {exc_type.__name__}: {exc_val}")
        # Return True to suppress the exception, False or None to propagate
        return False # Propagate exceptions by default

async def use_resource(name):
    try:
        async with AsyncResource(name) as resource:
            print(f"Using resource {resource.name}...")
            await asyncio.sleep(1)
            if name == "flaky_resource":
                raise RuntimeError("Simulated error during resource use")
            print(f"Finished using resource {resource.name}.")
    except RuntimeError as e:
        print(f"Caught exception outside context manager: {e}")

async def main():
    await use_resource("stable_resource")
    print("---")
    await use_resource("flaky_resource")

if __name__ == "__main__":
    asyncio.run(main())

            

              
                Copy
              
            
          

            import asyncio
import logging

logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

async def log_task(name, delay):
    logging.info(f"Task '{name}' started.")
    try:
        await asyncio.sleep(delay)
        if delay > 1:
            raise ValueError(f"Simulated error for '{name}' due to long delay.")
        logging.info(f"Task '{name}' completed successfully after {delay}s.")
    except asyncio.CancelledError:
        logging.warning(f"Task '{name}' was cancelled.")
        raise
    except Exception as e:
        logging.error(f"Task '{name}' encountered an error: {e}")
        raise

async def main():
    tasks = [
        asyncio.create_task(log_task("Task A", 1)),
        asyncio.create_task(log_task("Task B", 2)),
        asyncio.create_task(log_task("Task C", 0.5))
    ]
    await asyncio.gather(*tasks, return_exceptions=True)
    logging.info("All tasks have finished.")

if __name__ == "__main__":
    asyncio.run(main())

            

              
                Copy
              
            
          

            import asyncio

async def potentially_buggy_coro():
    # This is a simplified example. Debug mode catches more subtle issues.
    await asyncio.sleep(0.1)
    # Example: If this were to accidentally block the loop

async def main():
    print("Running with asyncio debug mode enabled.")
    await potentially_buggy_coro()

if __name__ == "__main__":
    asyncio.run(main(), debug=True)

            

              
                Copy
              
            
          

            import asyncio
import time

async def long_running_task(duration):
    print(f"Starting task that takes {duration} seconds.")
    await asyncio.sleep(duration)
    print("Task finished naturally.")
    return "Task Completed"

async def main():
    print(f"Current time: {time.strftime('%X')}")
    try:
        # Set a global timeout for all operations
        result = await asyncio.wait_for(long_running_task(5), timeout=3.0)
        print(f"Operation successful: {result}")
    except asyncio.TimeoutError:
        print(f"Operation timed out after 3 seconds!")
    except Exception as e:
        print(f"An unexpected error occurred: {e}")

    print(f"Current time: {time.strftime('%X')}")

if __name__ == "__main__":
    asyncio.run(main())

            

              
                Copy